import json
import re

def main(arg1: str) -> dict:
    # 预处理步骤：删除<think></think>标签及其内容
    def preprocess_text(text):
        """删除think标签及其内容"""
        # 使用正则表达式删除<think>...</think>标签及内容
        # re.DOTALL让.匹配包括换行符在内的所有字符
        cleaned_text = re.sub(r'<think>.*?</think>', '', text, flags=re.DOTALL)
        return cleaned_text.strip()
    
    # 对输入文本进行预处理
    processed_text = preprocess_text(arg1)
    
    # 修复后的正则表达式，支持多种JSON代码块格式
    JSON_PATTERNS = [
        # 标准格式: ```json ... ```
        re.compile(r'```json\s*(.*?)\s*```', re.DOTALL),
        # 缺少开头```: json ... ```
        re.compile(r'(?<!</think>)json\s*\n(.*?)\s*```', re.DOTALL),
        # think标签后直接json: </think>json ... ```
        re.compile(r'</think>json\s*\n(.*?)\s*```', re.DOTALL),
        # 只有花括号，没有代码块标记
        re.compile(r'(\{.*\})', re.DOTALL),
        # 匹配被引号包围的JSON字符串
        re.compile(r'"(\{.*\})"', re.DOTALL),
        # 匹配不完整的JSON（以{开头但可能没有结尾}）
        re.compile(r'(\{.*)', re.DOTALL),
    ]
    
    def extract_json_robust(text):
        """提取并自动修复JSON格式异常"""
        return extract_and_fix_json(text)
    
    def extract_and_fix_json(text):
        json_str = None
        is_escaped_string = False
        
        # 尝试不同的正则表达式模式
        for i, pattern in enumerate(JSON_PATTERNS):
            match = pattern.search(text)
            if match:
                json_str = match.group(1).strip()
                # 如果是被引号包围的模式，标记为转义字符串
                if i == 4:  # 第5个模式（索引4）
                    is_escaped_string = True
                break
        
        if not json_str:
            # 如果没有匹配到模式，尝试直接解析整个文本
            json_str = text.strip()
            # 检查是否是被引号包围的字符串
            if json_str.startswith('"') and json_str.endswith('"'):
                is_escaped_string = True
                json_str = json_str[1:-1]  # 去除外层引号
        
        if not json_str:
            return None
        
        # 如果是转义字符串，先进行JSON字符串解析
        if is_escaped_string:
            try:
                json_str = json.loads(f'"{json_str}"')
            except json.JSONDecodeError:
                pass
        
        # 优先尝试直接解析
        try:
            return json.loads(json_str)
        except json.JSONDecodeError:
            pass
        
        # 修复后再试
        return try_fix_json(json_str)
    
    def try_fix_json(json_str):
        # 修复策略1：基础清理
        fixed = basic_cleanup(json_str)
        try:
            return json.loads(fixed)
        except json.JSONDecodeError:
            pass
        
        # 修复策略2：智能补全缺失的括号
        fixed = smart_complete_json(fixed)
        try:
            return json.loads(fixed)
        except json.JSONDecodeError:
            pass
        
        # 修复策略3：引号修复
        fixed = fix_quotes(fixed)
        try:
            return json.loads(fixed)
        except json.JSONDecodeError:
            pass
        
        # 修复策略4：逗号修复
        fixed = fix_commas(fixed)
        try:
            return json.loads(fixed)
        except json.JSONDecodeError:
            pass
        
        # 修复策略5：基础括号修复
        fixed = fix_brackets(fixed)
        try:
            return json.loads(fixed)
        except json.JSONDecodeError:
            pass
        
        # 修复策略6：部分提取
        partial_json = extract_partial_json(json_str)
        if partial_json:
            try:
                return json.loads(partial_json)
            except json.JSONDecodeError:
                pass
        
        # 修复策略7：截断修复（处理不完整的JSON）
        fixed = fix_truncated_json(json_str)
        if fixed:
            try:
                return json.loads(fixed)
            except json.JSONDecodeError:
                pass
        
        return None
    
    def smart_complete_json(json_str):
        """智能补全JSON结构"""
        # 移除末尾可能的不完整内容
        json_str = json_str.strip()
        
        # 如果字符串以逗号结尾，移除它
        if json_str.endswith(','):
            json_str = json_str[:-1]
        
        # 统计括号数量
        brace_stack = []
        bracket_stack = []
        in_string = False
        escape_next = False
        
        for i, char in enumerate(json_str):
            if escape_next:
                escape_next = False
                continue
                
            if char == '\\':
                escape_next = True
                continue
                
            if char == '"' and not escape_next:
                in_string = not in_string
                continue
                
            if not in_string:
                if char == '{':
                    brace_stack.append(i)
                elif char == '}' and brace_stack:
                    brace_stack.pop()
                elif char == '[':
                    bracket_stack.append(i)
                elif char == ']' and bracket_stack:
                    bracket_stack.pop()
        
        # 补全缺失的括号
        result = json_str
        
        # 先补全方括号
        for _ in bracket_stack:
            result += ']'
        
        # 再补全花括号
        for _ in brace_stack:
            result += '}'
            
        return result
    
    def fix_truncated_json(json_str):
        """修复被截断的JSON"""
        json_str = json_str.strip()
        
        # 如果不是以{开头，不处理
        if not json_str.startswith('{'):
            return None
        
        # 找到最后一个完整的字段
        lines = json_str.split('\n')
        complete_lines = []
        
        for line in lines:
            line = line.strip()
            if not line:
                continue
                
            # 如果这一行看起来像一个完整的字段
            if (line.endswith(',') or 
                line.endswith('}') or 
                line.endswith(']') or 
                (line.endswith('"') and ':' in line)):
                complete_lines.append(line)
            # 如果这一行包含完整的key-value对
            elif re.match(r'^\s*"[^"]+"\s*:\s*(.+)[,}]?\s*$', line):
                # 移除末尾可能不完整的部分
                if line.endswith(','):
                    complete_lines.append(line)
                else:
                    # 尝试补全这一行
                    if ':' in line and not line.endswith(('"', '}', ']', ',')):
                        # 可能是字符串值被截断了
                        if line.count('"') % 2 == 1:  # 奇数个引号，说明字符串没有闭合
                            line += '"'
                        if not line.endswith(','):
                            line += ','
                    complete_lines.append(line)
            else:
                # 这一行可能不完整，跳过
                break
        
        if not complete_lines:
            return None
        
        # 重新构建JSON
        result = '{\n'
        for i, line in enumerate(complete_lines):
            if i == len(complete_lines) - 1:
                # 最后一行，移除末尾的逗号
                if line.endswith(','):
                    line = line[:-1]
            result += '  ' + line + '\n'
        result += '}'
        
        return result
    
    def basic_cleanup(json_str):
        # 移除行注释
        json_str = re.sub(r'//.*', '', json_str)
        # 移除块注释
        json_str = re.sub(r'/\*.*?\*/', '', json_str, flags=re.DOTALL)
        # 将制表符转换为空格
        json_str = json_str.replace('\t', '  ')
        # 移除多余的空白字符但保留必要的换行
        json_str = re.sub(r'[ ]+', ' ', json_str)
        json_str = json_str.strip()
        return json_str
    
    def fix_quotes(json_str):
        json_str = re.sub(r"'([^']*?)'(\s*:)", r'"\1"\2', json_str)
        json_str = re.sub(r":\s*'([^']*?)'", r': "\1"', json_str)
        json_str = re.sub(r'(\w+)(\s*:)', r'"\1"\2', json_str)
        return json_str
    
    def fix_commas(json_str):
        json_str = re.sub(r',\s*([}$$])', r'\1', json_str)
        json_str = re.sub(r'"\s*\n\s*"', '",\n  "', json_str)
        json_str = re.sub(r'}\s*\n\s*{', '},\n  {', json_str)
        json_str = re.sub(r']\s*\n\s*$$', '],\n  [', json_str)
        return json_str
    
    def fix_brackets(json_str):
        open_braces = json_str.count('{')
        close_braces = json_str.count('}')
        open_brackets = json_str.count('[')
        close_brackets = json_str.count(']')
        
        if open_braces > close_braces:
            json_str += '}' * (open_braces - close_braces)
        
        if open_brackets > close_brackets:
            json_str += ']' * (open_brackets - close_brackets)
        
        return json_str
    
    def extract_partial_json(json_str):
        brace_count = 0
        start_pos = json_str.find('{')
        
        if start_pos == -1:
            return None
        
        for i, char in enumerate(json_str[start_pos:], start_pos):
            if char == '{':
                brace_count += 1
            elif char == '}':
                brace_count -= 1
                if brace_count == 0:
                    return json_str[start_pos:i+1]
        
        return None
    
    # 主逻辑：对预处理后的文本调用JSON提取函数
    res = extract_json_robust(processed_text)
    
    return {
        "result": res,
    }